/*******************************************************************************
**
** Filename: 	zpp.l
** {{{
** Project:	Zip CPU -- a small, lightweight, RISC CPU core
**
** Purpose:	The preprocessor for the Zip Assembler.
**
**	This routine strips comments, handles #define's, #ifdef's, and
**	#include statements in a C fashion.
**
**	#define macro's are also defined in the language and therefore
**	supposed to be supported, but the support isn't there yet.
**
** Creator:	Dan Gisselquist, Ph.D.
**		Gisselquist Technology, LLC
**
********************************************************************************
** }}}
** Copyright (C) 2015-2023, Gisselquist Technology, LLC
** {{{
** This program is free software (firmware): you can redistribute it and/or
** modify it under the terms of  the GNU General Public License as published
** by the Free Software Foundation, either version 3 of the License, or (at
** your option) any later version.
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
** FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
** for more details.
**
** You should have received a copy of the GNU General Public License along
** with this program.  (It's in the $(ROOT)/doc directory, run make with no
** target there if the PDF file isn't present.)  If not, see
** <http://www.gnu.org/licenses/> for a copy.
** }}}
** License:	GPL, v3, as defined and found on www.gnu.org,
**		http://www.gnu.org/licenses/gpl.html
**
**
*******************************************************************************/

%{
// #include <FlexLexer.h>
#include <string>
#include <ctype.h>
#include <stdio.h>
#include <list>
#include <vector>
#include <assert.h>

using namespace std;

int yylex();
void	mark_line(void);
int	end_of_file(void);
void	pushf(const char *fname);

// #include "zprepr.tab.h"
int	ndef = 0, structno = 0;
char	*structid = NULL;
void	stb_define(const char *str);
bool	stb_current(const char *str);
bool	stb_hasargs(const char *str);
void	stb_expand(FILE *fout, const char *str);
std::string	stb_expand(const char *str);
void	stb_args(const char *str);
void	stb_macro(const char *value);
void	stb_addmacro(const char *value);
bool	stb_isdefined(const char *str);
const char	*stb_getdefn(const char *str);
%}
%x DEF DFA DFV DFV_EOL INDEF IFDEFV INNOTDEF NODEF NVRDEF COMMENT INSTRUCT
%x INDEF_EOL INNOTDEF_EOL GETSTRUCTID NVRDEF_EOL DONTDEF
%option noyywrap
%option stack
ID [_:A-Za-z][_:A-Za-z0-9]*
IDDOT {ID}("."{ID})*

%%
<COMMENT>"*/"		{ yy_pop_state(); }
<COMMENT>[^*\n]+	{ /* Ignore comments */ }
<COMMENT>"*"+[^/]	{ /* Ignore comments */ }
<INITIAL,INDEF>^"#include"[ \t]+\"[^\n\"]+\"	{
		char *ptr = &yytext[9], *start, *end, *str;
		while(isspace(*ptr))
			ptr++;
		start = ++ptr;
		ptr++;
		while((*ptr)&&(*ptr != '\"'))
			ptr++;
		*ptr = '\0';
		pushf(start);
		// push_file_state(yylineno); // and filename ...
		mark_line();
	}
<INITIAL,INDEF>^"#define"[ \t]+	{ yy_push_state(DEF); }
 /* <*>^"#line"[ \t]+(0-9)+[ \t]+["][^"]*["][ \t]*\n	{ } */
<DEF>{IDDOT}/[^(]	{
		// fprintf(stderr, "Defining \'%s\'\n", yytext);
		stb_define(yytext);
		BEGIN DFV;
	}
<DEF>{IDDOT}/[(]	{ stb_define(yytext); BEGIN DFA; }
<DFA>"("[^)\n]+")"				{
		/* Process macro arguments */
		stb_args(yytext);
		BEGIN DFV;
	}
<DFV>^[ \t]+	{ stb_macro(yytext); /* Replicate initial spaces */ }
<DFV>[ \t]+	{ stb_macro(" "); /* Ignore all  but one internal space */ }
<DFV>{ID}	{/* Parse to end of line, get value for our define */
		// fprintf(stderr, "%s may be a macro, line %d\n", yytext, yylineno);
		if ((!stb_current(yytext))&&(stb_isdefined(yytext))) {
			// fprintf(stderr, "Recursive MACRO!\n");
			stb_macro(stb_getdefn(yytext));
		} else {
			// fprintf(stderr, "But it is not defined\n");
			stb_macro(yytext);
		}
	}
<DFV>{ID}[ \t]*[(][ \t]*{ID}[ \t]*(,[ \t]*{ID}[ \t]*)*[)]	{ 
		// fprintf(stderr, "%s may be a macro within a macro!\n", yytext);
		if ((!stb_current(yytext))&&(stb_isdefined(yytext))) {
			if (stb_hasargs(yytext)) {
				std::string str = stb_expand(yytext);
				stb_macro(str.c_str());
			} else {
				char *dup = strdup(yytext), *ptr;
				ptr = strchr(dup, '(');
				*ptr = '\0';
				stb_macro(stb_getdefn(dup));
				free(dup);
				yyless(strchr(yytext,'(')-yytext);
			}
		} else if (!stb_current(yytext)) {
			stb_macro(yytext);
		} else {
			char *dup = strdup(yytext), *ptr;
			ptr = strchr(dup, '(');
			*ptr = '\0';
			stb_macro(stb_getdefn(dup));
			free(dup);
			yyless(strchr(yytext,'(')-yytext);
		}
	}
<DFV>[^a-zA-Z_0-9 \t\n]+	{/* Parse to end of line, get value for our define */
		// fprintf(stderr, "A: Adding to macro %s\n", yytext);
		stb_macro(yytext);
	}
<DFV>0[xX][0-9A-Fa-f]+	{/* Get any hexadecimal constants */
		// fprintf(stderr, "B: Adding to macro %s\n", yytext);
		stb_macro(yytext);
	}
<DFV>[0-9A-Fa-f]+[hH]	{/* Get any hexadecimal constants */
		// fprintf(stderr, "C: Adding to macro %s\n", yytext);
		stb_macro(yytext);
	}
<DFV>[0-7]+[oO]	{/* Get any octal constants */
		// fprintf(stderr, "D: Adding to macro %s\n", yytext);
		stb_macro(yytext);
	}
<DFV>[0-9]+	{/* Get any decimal constants */
		// fprintf(stderr, "E: Adding to macro %s\n", yytext);
		stb_macro(yytext);
	}
<DFV>[ \t]*((;|"//").*)?$	{/* Parse to end of line, get value for our define */
		yy_pop_state();
	}
<DFV>[ \t]*"\\"[ \t]*((;|"//").*)?\n	{/* Continue onto next line */
		fprintf(yyout, "\n"); mark_line(); yylineno++;
		stb_macro("\n");
	}
<INNOTDEF,NODEF,NVRDEF>^"#define".*$	{ yy_push_state(DONTDEF); }
<DONTDEF>"\\"[ \t]*((;"//").*)?\n	{/* Continue onto next line */
		fprintf(yyout, "\n"); mark_line(); yylineno++; }
<DONTDEF>[a-zA-Z0-9_,.()]*	{ }
<DONTDEF>[ \t]*			{ }
<DONTDEF>((;|"//").*)?$		{ yy_pop_state(); }
<DONTDEF>"\\"[ \t]*((;|"//").*)?\n	{/* Continue onto next line */
		fprintf(yyout, "\n"); mark_line(); yylineno++; }
<INITIAL,INDEF>^[ \t]+.[dD][aA][tT][aA]?	{ fprintf(yyout, "\tWORD"); }
<INITIAL,INDEF>^"#defcont"[ \t]+	{
		yy_push_state(DFV); }
<INITIAL,INDEF>^"#ifdef"[ \t]*	{ ndef = 0;
		yy_push_state(IFDEFV); }
<INITIAL,INDEF>^"#ifndef"[ \t]*	{ ndef = 1;
		yy_push_state(IFDEFV); }
<INNOTDEF,NODEF,NVRDEF>^"#ifdef"[ \t]*	{ ndef = 2;
		yy_push_state(IFDEFV); }
<INNOTDEF,NODEF,NVRDEF>^"#ifndef"[ \t]*	{ ndef = 2;
		yy_push_state(IFDEFV); }
<IFDEFV>{IDDOT}	{
		bool	known = stb_isdefined(yytext);
		if (ndef == 2) {
			BEGIN NVRDEF_EOL;
		} else if ( ((known)&&(ndef==0)) || ((!known)&&(ndef!=0)) ) {
			BEGIN INDEF_EOL;
		} else {
			BEGIN INNOTDEF_EOL;
		}
	}
	/* Not yet: <INITIAL,INDEF>^"#if"[ \t]*		{ yy_push_state(IFDEFE); }
	/* Not yet: <INITIAL,INDEF>^"#if"[ \t]*		{ yy_push_state(IFDEFE); }
	/* Not yet: <IFDEFE><expr> { yy_push_state(IFDEFE); } */
	/* <INNOTDEF>^"#elsif"[ \t]*	{ yy_pop_state(); yy_push_state(IFDEFE); } */
<INDEF_EOL>[ \t]*$		{ BEGIN INDEF; }
<INDEF_EOL>(;|"//").*$		{ BEGIN INDEF; }
<INNOTDEF_EOL>[ \t]*$		{ BEGIN INNOTDEF; }
<INNOTDEF_EOL>(;|"//").*$	{ BEGIN INNOTDEF; }
<NVRDEF_EOL>[ \t]*$		{ BEGIN NVRDEF; }
<NVRDEF_EOL>(;|"//").*$		{ BEGIN NVRDEF; }
<NVRDEF_EOL>[^ \t\n].*$		{ BEGIN INDEF; mark_line(); }
<INNOTDEF_EOL>[^ \t\n].*$	{ BEGIN INNOTDEF; mark_line(); }
<INDEF,NVRDEF>^"#else"[ \t]*((;|"//").*)?$	{ BEGIN NODEF; }
<INNOTDEF>^"#else"[ \t]*((;|"//").*)?$		{ BEGIN INDEF; }
<INNOTDEF,NVRDEF,NODEF>^[^#\n]([^\n]*)$		{ /* Skip text */ }
<INDEF>^"#elsif"[ \t]*		{ BEGIN NVRDEF; }
<NVRDEF,NODEF,INDEF,INNOTDEF>^"#endif"[ \t]*((;|"//").*)?$	{
				yy_pop_state(); }
<NVRDEF,NODEF,INDEF,INNOTDEF>^"#endif"[ \t]*"/*"	{ BEGIN COMMENT; }
<NVRDEF,NODEF,INDEF,INNOTDEF>^"#endif"	{ yy_pop_state(); }
<*>^"#ifdef"[ \t]*		{ fprintf(stderr, "ERR: Line %d, Unknown ifdef!! (state = %d)\n", yylineno, YYSTATE);}
<*>^"#else"[ \t]*		{ fprintf(stderr, "ERR: Line %d, Unknown else!! (state = %d)\n", yylineno, YYSTATE);}
<*>^"#endif"[ \t]*		{ fprintf(stderr, "ERR: Line %d, Unknown endif!! (state = %d)\n", yylineno, YYSTATE);}
<INITIAL,INDEF>^"#struct"[ \t]*	{ yy_push_state(GETSTRUCTID); structno  = 0; }
<*>^"#"{ID}[ \t]*		{
	fprintf(stderr, "ERR: Line %d, unrecognized preprocessor instruction, \'%s\' (state = %d)\n",
			yylineno, yytext, YYSTATE);
	}
<GETSTRUCTID>{ID}/[ \t\n;/]	{ BEGIN INSTRUCT;
		structid = strdup(yytext);
		}
<INSTRUCT>{ID}("."{ID})*	{ 
		fprintf(yyout, "\t%s.%s\tequ\t%d", structid, yytext, structno++); }
<INSTRUCT>^"#endstruct".*$	{ yy_pop_state(); }
	/* Not yet: ^"#struct"[ \t]*	{}	*/
	/* Not yet: ^"#endstruct"[ \t]*	{}	*/
	/* Not yet: ^"#seg"[ \t]*	{}	*/
<INITIAL,INDEF>{ID}/[^(]	{ 
		if (stb_isdefined(yytext))
			fprintf(yyout, "%s", stb_getdefn(yytext));
		else
			fprintf(yyout, "%s", yytext);
	}
<INITIAL,INDEF>{ID}([ \t]*)	{ 
		if (stb_isdefined(yytext))
			fprintf(yyout, "%s", stb_getdefn(yytext));
		else
			fprintf(yyout, "%s", yytext);
	}
<INITIAL,INDEF>{ID}[ \t]*[(][ \t]*{ID}[ \t]*(,[ \t]*{ID}[ \t]*)*[)]	{ 
		// fprintf(stderr, "%s may be a macro!\n", yytext);
		if (stb_isdefined(yytext)) {
			if (stb_hasargs(yytext)) {
				stb_expand(yyout, yytext);
			} else {
				fprintf(yyout, "%s", stb_getdefn(yytext));
				yyless(strchr(yytext,'(')-yytext);
			}
		} else {
			// fprintf(stderr, "But it is not defined\n");
			fprintf(yyout, "%s", yytext);
		}
	}
<INITIAL,INDEF>"\'"(("\\\'")|([^'\\])|("\\"[0abfnrtv])|("\\\\")|("\\\"")){1,4}"\'" { ECHO; }
<*>[ \t]*"//".*$	{ /* Ignore (trailing) comment only lines */ }
<*>[ \t]*";".*$		{ /* Ignore (trailing) comment only lines */ }
<*>"#warning".*$	{ fprintf(stderr, "WARNING: %s\n", &yytext[8]); }
<*>"#error".*$		{ fprintf(stderr, "ERROR: %s\n", &yytext[8]); exit(-1); }
<*>"/*"			{ yy_push_state(COMMENT); }
<*>[ \t]+		{ ECHO; }
<*>\n			{ ECHO; yylineno++; mark_line(); }
	/* <*>.			{ printf("Unmatched \'%c\'\n", yytext[0]); } */
<NVRDEF,NODEF,INDEF,INNOTDEF><<EOF>>	{ fprintf(stderr, "Unexpected EOF!  Expecting #endif\n"); yyterminate(); }
<IFDEFV><<EOF>>		{ fprintf(stderr, "Unexpected EOF!  Expecting #endif\n"); yyterminate(); }
<COMMENT><<EOF>>	{ fprintf(stderr, "Unexpected EOF!  Expecting */\n"); yyterminate(); }
<INSTRUCT><<EOF>>	{ fprintf(stderr, "Unexpected EOF!  Expecting #endstruct\n"); yyterminate(); }
<GETSTRUCTID><<EOF>>	{ fprintf(stderr, "Unexpected EOF!  Expecting #struct ID, then #endstruct\n"); yyterminate(); }
<DFA,DFV,DFV_EOL><<EOF>> { fprintf(stderr, "Unexpected EOF!  Expecting end of line\n"); yyterminate(); }
<INDEF_EOL,INNOTDEF_EOL><<EOF>	{ fprintf(stderr, "Unexpected EOF  Expecting end of line, then #endif\n"); yyterminate(); }
<INITIAL><<EOF>>	{ if (end_of_file()) yyterminate(); }

%%

class	SYMTABLE_ACTION {
public:
	// Types: 0 (end of actions), 1-X, argument number, <0 raw string
	int		m_type;
	std::string	m_str;		// if m_type < 0, have m_str
};

class	SYMTABLE_ENTRY {
private:
	bool	m_reduced;
	std::string	&trim(std::string &s) {
		std::string::iterator	ptr = s.end();

		while((ptr >= s.begin())&&(isspace(*ptr)))
			*ptr-- = '\0';

		return s;
	}

public:
	std::string	m_name, m_value, m_args;
	std::vector<SYMTABLE_ACTION>	m_actions;
	SYMTABLE_ENTRY(const char *str) : m_name(str) {
		trim(m_name);
		m_reduced = false;
	}
	SYMTABLE_ENTRY &operator+=(const char *str) {
		const char	*start = str;

		while(isspace(*start))
			start++;
		if (m_value.length()!=0)
			m_value += " ";

		m_value += str;

		/*
		printf("ENTRY::SYMBOL \'%s\' NOW = \'%s\'\n",
			m_name.c_str(), m_value.c_str());
		*/
		return *this;
	}
	SYMTABLE_ENTRY &setargs(const char *str) {
		m_args += str;
		return *this;
	}

	const std::string &getdefn(void) {
		return m_value;
	}

	bool	hasargs(void) {
		return (m_args.size()>0);
	}

	void	reduce(void) {
		if (m_reduced)
			return;

		// fprintf(stderr, "Reducing %s ( %s ) \n", m_name.c_str(), m_args.c_str());
		std::vector<std::string>	alist;
		int i=0, bg, en;
		do {
			if ((m_args[i] == ',')||(m_args[i] == '('))
				i++;
			while((m_args[i])&&(isspace(m_args[i])))
				i++;
			bg = i;
			while((m_args[i])&&(
				(isalpha(m_args[i]))
				||(m_args[i]==':')
				||(m_args[i]=='_')
				||(isdigit(m_args[i]))))
				i++;
			en = i;
			while((m_args[i])&&(isspace(m_args[i])))
				i++;

			alist.push_back(m_args.substr(bg,en-bg));
			// printf("Found argument %2ld of %s: \'%s\'\n",
				// alist.size(),
				// m_name.c_str(),
				// m_args.substr(bg,en-bg).c_str());
		} while((m_args[i])&&(m_args[i] == ','));

		assert(m_args[i] == ')');

		// Now that we know our arguments, lets look for these
		// arguments in our macro definition
		std::string	building;
		i = 0;
		while(m_value[i]) {
			int	nxti = m_value.size(), nxtv;
			for(int a=0; a<alist.size(); a++) {
				const char *ptr;
				ptr = strstr(m_value.c_str()+i, alist[a].c_str());
				while((ptr)&&(ptr-m_value.c_str() < nxti)) {
					int loc = ptr-m_value.c_str();
					const char *pre = ptr-1;
					const char *pst = ptr+alist[a].size();
					if ((loc < nxti)&&(
						(loc == i)
						||((!isalpha(*pre)
							&&(*pre != '_')
							&&(*pre != ':')
							&&(!isdigit(*pre)))))
						&&((*pst=='\0')
					  	||(	(!isalpha(*pst))
							&&(*pst != '_')
							&&(*pst != ':')
							&&(!isdigit(*pst)))))
					{
					 		nxti = loc;
							nxtv = a;
							break;
					} else {
						ptr = strstr(m_value.c_str()+loc, alist[a].c_str());
						loc = ptr-m_value.c_str();
					}
				}
			}

			if (nxti < m_value.size()) {
				// Found an argument!!
				SYMTABLE_ACTION	act;
				if (nxti > i) {
					act.m_type = -1;
					act.m_str = m_value.substr(i,nxti-i);
					// printf("ACTION: \'%s\'\n", act.m_str.c_str());
					m_actions.push_back(act);
				}
				act.m_type = nxtv;
				act.m_str = "";
				m_actions.push_back(act);
				// printf("ACTION[%2d]: \'%s\'\n", nxtv, alist[nxtv].c_str());
				
				i = nxti+alist[nxtv].size();
			} else break; // No more arguments
		} if (i<m_value.size()) {
			SYMTABLE_ACTION act;
			act.m_type = -1;
			act.m_str = m_value.substr(i);
			// printf("ACTION: \'%s\'\n", act.m_str.c_str());
			m_actions.push_back(act);
		}
		m_reduced = true;
	}

	std::string expand(std::string args) {
		if (!m_reduced)
			reduce();
		std::vector<std::string>	alist;
		std::string	result;

		// printf("Expanding %s\n", args.c_str());
		int i=0, bg, en, nest=-1;
		do {
			if ((args[i] == '(')||(args[i] == ',')) {
				if (args[i] =='(')
					nest++;
				i++;
			}
			while((args[i])&&(isspace(args[i])))
				i++;
			bg = i;
			while((args[i])&&(args[i] != ',')&&((args[i] != ')')||(nest != 0))) {
				if (args[i] == '(')
					nest++;
				else if (args[i] == ')')
					nest--;
				i++;
			} en = i-1;
			while((en>0)&&(isspace(args[en])))
				en--;
			alist.push_back(args.substr(bg,en+1-bg));
			// printf("Argument %2ld of %s maps to \'%s\'\n",
				// alist.size(),
				// m_name.c_str(),
				// args.substr(bg,en+1-bg).c_str());
		} while((args[i])&&(args[i] == ','));

		// printf("At end, args[i] = \'%s\'\n", &args[i]);
		assert(args[i] == ')');

		// printf("Filling in %ld actions\n", m_actions.size());
		for(i=0; i<m_actions.size(); i++) {
			if((m_actions[i].m_type >= 0)&&(m_actions[i].m_type < alist.size()))
				result += alist[m_actions[i].m_type].c_str();
			else if (m_actions[i].m_type < 0)
				result += m_actions[i].m_str.c_str();
			// else {
				// fprintf(fout, "m_type = %d, size = %ld\n", m_actions[i].m_type, alist.size());
			// }
		}

		return result;
	}
};

class	SYMBOL_TABLE {
private:
	typedef	SYMTABLE_ENTRY 	*TBLV;
	typedef	std::list<TBLV>	TBLT;

	TBLT	m_tbl;
	TBLT::iterator	lookup(const char *str) {
		TBLT::iterator	i = m_tbl.begin();
		for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
			;
		if ((i != m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())==0))
			return i;
		return m_tbl.end();
	}

public:
	SYMBOL_TABLE(void) {}

	void define(const char *str) {
		SYMTABLE_ENTRY	*v = new SYMTABLE_ENTRY(str);
		TBLT::iterator	i = m_tbl.begin();
		for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
			;
		m_tbl.insert(i, v);

		// fprintf(stderr, "SYMS::Defining SYMBOL: \'%s\'\n", str);
	}

	bool defined(const char *str) {
		TBLT::iterator	i = lookup(str);
		if (i==m_tbl.end())
			return false;
		else
			return true;
	}


	void	undefine(const char *str) {
		TBLT::iterator	i = lookup(str);
		if (i == m_tbl.end())
			return;
		TBLV	v = (*i);
		m_tbl.erase(i);
		delete	v;
	}

	void	addmacro(const char *name, const char *str) {
		TBLT::iterator i = lookup(name);
		if (i == m_tbl.end()) {
			fprintf(stderr, "ADDMACRO::INTERNAL ERR, \'%s\' NOT DEFINED!\n", name);
		} *(*i) += str;
	}
				
	void	addargs(const char *name, const char *str) {
		TBLT::iterator i = lookup(name);
		if (i == m_tbl.end()) {
			fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
		} (*i)->setargs(str);
	}
	bool	hasargs(const char *name) {
		TBLT::iterator i = lookup(name);
		if (i == m_tbl.end()) {
			return false;
		} return (*i)->hasargs();
	}
	const	char *getdefn(const char *name) {
		TBLT::iterator i = lookup(name);
		if (i == m_tbl.end()) {
			fprintf(stderr, "GETDEFN::INTERNAL ERR, \'%s\' NOT DEFINED!\n", name);
			return NULL;
		} (*i)->getdefn().c_str();
	}

	std::string	expand(const char *name, const char *ptr) {
		TBLT::iterator  i = lookup(name);
		if (i==m_tbl.end())
			return std::string("");
		return (*i)->expand(std::string(ptr));
	}
				
};

SYMTABLE_ENTRY	*last = NULL;
SYMBOL_TABLE	syms;
std::string	last_define;

char	*stb_trim(const char *str) {
	// fprintf(stderr, "Checking whether %s needs to be expanded\n",str);
	char *dup = strdup(str), *chr;
	chr = strchr(dup, '(');
	if (chr != NULL)
		*chr = '\0';
	// fprintf(stderr, "\tLooking it up by the name \'%s\'\n", dup);

	// Now, let's trim our string
	char	*end = dup+strlen(dup)-1;
	while((*dup)&&(end>dup)&&(isspace(*end)))
		*end-- = '\0';
	return dup;
}

void	stb_define(const char *str) {
	/*
	if (last_define.size()>0) {
		fprintf(stderr, "LAST-DEFINE(%s): %s\n", last_define.c_str(),
			stb_getdefn(last_define.c_str()));
	} */
	char	*alt = stb_trim(str);
	if (syms.defined(alt)) {
		fprintf(stderr, "WARNING!  Symbol \'%s\' is already defined!\n", str);
		syms.undefine(str);
	}

	syms.define(alt);
	last_define = alt;
	free(alt);
}

void	stb_args(const char *args) {
	syms.addargs(last_define.c_str(), args);
}

void	stb_macro(const char *value) {
	syms.addmacro(last_define.c_str(), value);
}

void	stb_addmacro(const char *value) {
	syms.addmacro(last_define.c_str(),value);
}

bool	stb_isdefined(const char *str) {
	char	*dup = stb_trim(str);
	bool r = (syms.defined(dup));
	free(dup);
	return r;
}

const char *stb_getdefn(const char *str) {
	char	*dup = stb_trim(str);
	const char	*r;
	r = syms.getdefn(dup);
	free(dup);
	return r;
}

bool	stb_current(const char *str) {
	return (strcmp(str, last_define.c_str())==0);
}

bool	stb_hasargs(const char *str) {
	char	*dup = stb_trim(str);
	bool r = (syms.hasargs(dup));
	// fprintf(stderr, "\t%s has %sarguments\n", dup, (r)?"":"no ");
	free(dup);
	return r;
}

std::string	stb_expand(const char *macro) {
	const	char	*ptr;
	std::string	str;
	ptr = strchr(macro, '(');
	assert(ptr);
	ptr--;
	while((ptr>macro)&&(isspace(*ptr)))
		ptr--;
	char *nam = strndup(macro, ptr+1-macro);
	ptr = strchr(ptr, '(');
	// fprintf(stderr, "Requesting an expansion of %s -- %s\n", nam, ptr);
	str = syms.expand(nam, ptr);
	free(nam);

	return str;
}

void	stb_expand(FILE *fout, const char *macro) {
	std::string	str = stb_expand(macro);
	fprintf(fout, "%s", str.c_str());
}

class	BUFSTACK {
public:
	FILE		*m_fp;
	char		*m_fname;
	int		m_lineno;
	BUFSTACK	*m_prev;
	YY_BUFFER_STATE	m_bs;

	static	BUFSTACK	*curbs;
	static	const char	*curfilename;

	BUFSTACK(void) {
		m_fp = stdin;

		if (curbs)
			curbs->m_lineno = yylineno;
		m_prev = curbs;
		// m_bs = yy_create_buffer(fp, YY_BUF_SIZE);
		m_fname = strdup("(stdin)");
		// yy_switch_to_buffer(m_bs);
		m_bs = NULL;
		curbs = this;
		m_lineno = 1;
		curfilename = m_fname;

		yyrestart(m_fp);
		yylineno = 1;
	}

	BUFSTACK(const char *fname) {
		m_fp = fopen(fname, "r");
		if (!m_fp) {
			char *pathptr = getenv("ZIPINC");
			if (!pathptr) {
				fprintf(stderr, "Cannot open %s\n", fname);
				perror("O/S Err:");
				exit(-1);
			} else {
				char	*dptr, *colonp;
				char *pathcpy = new char[strlen(pathptr)+8192];
				strcpy(pathcpy, pathptr);

				// fprintf(stderr, "ZIPINC := %s\n", pathptr);
				dptr = pathptr;
				while((!m_fp)&&(NULL != (colonp = strchr(dptr, ':')))) {
					strncpy(pathcpy, dptr, colonp-pathptr);
					strcat(pathcpy, "/");
					strcat(pathcpy, fname);
					// fprintf(stderr, "Looking for include file, %s\n", pathcpy);
					if (access(fname, R_OK)==0)
						m_fp = fopen(pathcpy, "r");
					dptr = colonp+1;
				} if ((!m_fp)&&(*dptr)) {
					strcpy(pathcpy, dptr);
					strcat(pathcpy, "/");
					strcat(pathcpy, fname);
					// fprintf(stderr, "Looking for include file, %s\n", pathcpy);
					m_fp = fopen(pathcpy, "r");
				} if (!m_fp) {
					fprintf(stderr, "Cannot open %s\n", fname);
					perror("O/S Err:");
					exit(-1);
				}

				delete[] pathcpy;
			}
		}

		if (curbs)
			curbs->m_lineno = yylineno;
		m_prev = curbs;
		m_bs = yy_create_buffer(m_fp, YY_BUF_SIZE);
		m_fname = strdup(fname);
		yy_switch_to_buffer(m_bs);
		curbs = this;
		m_lineno = 1;
		curfilename = m_fname;

		yyrestart(m_fp);
		yylineno = 1;
	}

	~BUFSTACK(void) {
		// fprintf(stderr, "DELETING(%s)\n", m_fname);
		fclose(m_fp);
		free(m_fname);
		if (m_bs)
			yy_delete_buffer(m_bs);
		curbs = m_prev;

		if (curbs) {
			yy_switch_to_buffer(curbs->m_bs);
			yylineno = curbs->m_lineno;
			curfilename = curbs->m_fname;
		}
	}

	void	mark(void) {
		FILE	*fp = yyout;
		if (!fp) fp = stdout;
		fprintf(fp, "#line %d \"%s\"\n", yylineno, m_fname);
	}

	void	markline(void) {
		FILE	*fp = yyout;
		if (!fp) fp = stdout;
		fprintf(fp, "#line %d\n", yylineno);
	}

	static	void pop(void) {
		// fprintf(stderr, "POP! (%s)\n", curbs->m_fname);
		if (curbs)
			delete curbs;
	}
};

BUFSTACK *BUFSTACK::curbs = NULL;
const char *BUFSTACK::curfilename = NULL;

int		last_marked_line = -1;
const char	*last_marked_file = NULL;
void	mark_line(void) {
	if ((yylineno != last_marked_line+1)||(BUFSTACK::curfilename != last_marked_file))
		if (BUFSTACK::curfilename == last_marked_file)
			BUFSTACK::curbs->markline();
		else BUFSTACK::curbs->mark();
	last_marked_line = yylineno;
	last_marked_file = BUFSTACK::curfilename;
}

int	end_of_file(void) {
	BUFSTACK::pop();
	return (BUFSTACK::curbs == NULL);
}

void	pushf(const char *fname) {
	BUFSTACK	*bs = new BUFSTACK(fname);
}

int main(int argc, char **argv) {
	yylineno = 1;
	if (argc < 2) { // Stdin only
		BUFSTACK::curbs = new BUFSTACK();
		yylex();
	} else {
		for(int argn=1; argn<argc; argn++) {
			BUFSTACK	*bs = new BUFSTACK(argv[argn]);
			mark_line();
			yylex();
			// delete	bs;
		}
	}

	return 0;
}
// <NODEF,NVRDEF>.*		{ fprintf(stderr, "Ignoring everything, line %d, \'%s\'\n", yylineno, yytext); /* Ignore everything in these states*/ }

